C & C++ Multimedia Cyber Classroom

home *** CD-ROM | disk | FTP | other *** search

/ C & C++ Multimedia Cyber Classroom / C and C++ Multimedia Cyber Classroom (Prentice Hall) (1998).iso / cpphtp2 / cpphtp2.jar / chpt_21.gml < prev next >

Wrap

Text File | 1998-03-03 | 87KB | 2,179 lines

<html> <chapter> <section type=Popup name=Quotes title="Quotes"> <page> "...to thine own self be true,..." William Shakespeare, Hamlet </page> <page> "The die is cast." Julius Caesar </page> <page> "What's in a name? that which we call a rose By any other name would smell as sweet." William Shakespeare, Romeo and Juliet </page> <page> "O Diamond! Diamond! thou little knowest the mischief done!" Sir Isaac Newton </page> </section> <section type=Popup name=Answers title="Answers"> <page pagename="Answer 21.1"> Answer 21.1 a) binary scope resolution (::). b) const_cast. c) C-style, dynamic_cast, static_cast, or reinterpret_cast <foreign name="exercises" url="^Exercises::c:s0p0"> </page> <page pagename="Answer 21.2"> Answer 21.2 a) False. One programmer may inadvertently choose the same namespace as another. b) False. Namespaces can be nested. c) True. <foreign name="exercises" url="^Exercises::c:s0p1"> </page> <page pagename="Answer 21.3"> Answer 21.3 a) <tt>typeid or dynamic_cast</tt> b) <tt>using</tt> c) <tt>or</tt> d) <tt>mutable</tt> <foreign name="exercises" url="^Exercises::c:s0p2"> </page> <page pagename="Answer 21.4"> Answer 21.4 a) True. b) True. c) True. d) False. Keyword <tt>explicit</tt> can only be used with constructors. <foreign name="exercises" url="^Exercises::c:s0p3"> </page> <page pagename="Answer 21.13"> Answer 21.13 a) true b) true c) false d) false e) false f) false g) true <foreign name="exercises" url="^Exercises::c:s0p12"> </page> <page pagename="Answer 21.7"> Answer 21.7 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P21_07.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p6"> </page> <page pagename="Answer 21.8"> Answer 21.8 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P21_08.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p7"> </page> <page pagename="Answer 21.15"> Answer 21.15 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P21_15.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p16"> </page> </section> <section type=Body name=Default title="21 ANSI/ISO C++ Standard Language Additions"> <page> 21 ANSI/ISO C++ Standard Language Additions<hr> <a href="#s1p0">21.1<spacer width=20 height=1>Introduction</a> <a href="#s2p0">21.2<spacer width=20 height=1>bool Data Type</a> <a href="#s3p0">21.3<spacer width=20 height=1>static_cast Operator</a> <a href="#s4p0">21.4<spacer width=20 height=1>const_cast Operator</a> <a href="#s5p0">21.5<spacer width=20 height=1>reinterpret_cast Operator</a> <a href="#s6p0">21.6<spacer width=20 height=1>Namespaces</a> <a href="#s7p0">21.7<spacer width=20 height=1>Run-Time Type Information (RTTI)</a> <a href="#s8p0">21.8<spacer width=20 height=1>Operator Keywords</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> <page> <a href="#s9p0">21.9<tt><spacer width=20 height=1>explicit</tt> Constructors</a> <a href="#s10p0">21.10<spacer width=20 height=1>mutable Class Members</a> <a href="#s11p0">21.11<spacer width=20 height=1>Pointers to Class Members (.* and ->*)</a> <a href="#s12p0">21.12<spacer width=20 height=1>Multiple Inheritance and virtual Base Classes</a> <a href="#s13p0">21.13<spacer width=20 height=1>Closing Remarks</a> <a href="#s14p0">21.14<spacer width=20 height=1>Summary</a> <a href="^Terminology::c:s0p0">Terminology</a> <a href="^Illustration::c:s0p0">Figures</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> </section> <section type=Body name=Default title="21.1 Introduction"> <page> 21.1 Introduction<hr> We now consider some newer ANSI/ISO C++ Draft Standard features including data type bool, cast operators, namespaces, run-time type information (RTTI) and operator keywords. We also discuss pointers-to-class-member operators and virtual base classes--which are not new ANSI C++ features. This chapter was co-authored with Mr. Tem Nieto, the authors' colleague at Deitel & Associates, Inc. </page> </section> <section type=Body name=Default title="21.2 bool Data Type"> <page> 21.2 bool Data Type<hr> The ANSI/ISO C++ draft standard provides data type bool whose values may be false or true as a preferred alternative to the old style of using 0 to indicate false and nonzero to indicate true. The program of <a href="^Code::c:s0p0"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.1</a> demonstrates data type bool. <spacer width=16 height=1>Line 9 <pre> bool boolean = false; </pre> declares variable boolean to be of type bool and initializes boolean to false. Variable x is declared and initialized to 0. Line 12 <pre> cout << "boolean is " << boolean </pre> </page> <page> outputs boolean's value. The value 0 is output rather than the keyword false. Numeric values are the default display for bools. <spacer width=16 height=1>The value of x (input on line 14) is used as an if/ else's condition in line 20. If x is 0, the condition is false. Otherwise the condition is true. Note that negative values are nonzero and therefore true. <spacer width=16 height=1>Line 25 assigns true to boolean. The value of boolean (1) is output on line 26. A bool variable outputs as 0 or 1 by default. The stream insertion operator << has been overloaded to display bools as integers. <spacer width=16 height=1>Lines 27 and 28 </page> <page> <pre> cout << "\nboolean output with boolalpha manipulator is " << boolalpha << boolean << endl; </pre> uses the stream manipulator boolalpha to set the output stream to display bool values as the strings "true" and "false." Manipulator boolalpha can also be used on input. <spacer width=16 height=1>Pointers, ints, floats, etc. can be implicitly converted to bools. Zero <a href="^Practice::c:s0p1"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>values convert to false and nonzero values convert to true. For example the expression <pre> bool dc = false + x * 2 - b && true; </pre> </page> <page> would assign true to dc assuming x is 3, and b is true. Note that the right-hand portion of the assignment expression evaluates to 5, but this value is implicitly <a href="^Practice::c:s0p0"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>converted to true. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Manipulator boolalpha can be used with input."> Manipulator boolalpha cannot be used with input. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Variables of type bool are displayed as integer values of 1 (true) and 0 (false) by default."> The stream insertion operator has been overloaded to display bools as "true" or "false" by default. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Manipulator boolalpha is defined in <iomanip>. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.3 static_cast Operator"> <page> 21.3 static_cast Operator<hr> The ANSI/ISO C++ draft standard introduces four new cast operators to use in preference to the "old-style" casting that has been used in C and C++. The new casts are less powerful and more specific than old-style casting, which gives the program more precise control. Casting is dangerous and can often be a source of errors so the new-style casts are also easier to spot and to search for using automated tools. Another advantage to the new-style casts is that the four casts have completely separate purposes, whereas with the old- style casting the philosophy was "one cast fits all." </page> <page> C++ provides the static_cast operator for conversion between types. Type checking is performed at compile time. <a href="^Errors::c:s0p0"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>Operator static_cast performs standard conversions (e.g., void * to char *, int to float, etc.) and their inverses. The program of <a href="^Code::c:s0p1"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.2</a> demonstrates operator static_cast. <spacer width=16 height=1>The program declares classes BaseClass and DerivedClass. Each class defines a member function f. Lines 20 and 21 <pre> double d = 8.22; int x = static_cast< int >( d ); </pre> declare and initialize both d and x. The static_cast <a href="^Engineer::c:s0p0"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>operator converts d from double to </page> <page> int. The static_cast <a href="^Practice::c:s0p2"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>operator can be used for most conversions between fundamental data types such as int, double, float, etc. <spacer width=16 height=1>BaseClass object base is instantiated on line 25 and passed by reference to function test on line 26. The address passed into test is received in pointer basePtr. DerivedClass pointer derivedPtr is declared on line 33. Line 36 <pre> derivedPtr = static_cast< DerivedClass * > ( basePtr ); </pre> uses static_cast to downcast from BaseClass * to DerivedClass *. Although (as we saw in Chapter 9) downcasting from a base class pointer to a derived </page> <page> class pointer is a potentially dangerous operation, static_cast permits the cast. Function f is invoked off derivedPtr (line 37). </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Operator static_cast performs standard conversions between types. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Type-checking for operator static_cast is performed at compile-time. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Operator static_cast can be used for downcasting."> Operator static_cast cannot be used for downcasting from a base class to a derived class type. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.4 const_cast Operator"> <page> 21.4 const_cast Operator<hr> C++ provides the const_cast operator for casting away const or volatile. The program of <a href="^Code::c:s0p2"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.3</a> demonstrates the use of const_cast. <spacer width=16 height=1>Lines 5-12 declare class ConstCastTest that contains three member functions and private variable number. Two of the member functions are declared const. Function setNumber sets number's value. Function getNumber returns number's value. <spacer width=16 height=1>The const member function printNumber modifies number's value in line 24 </page> <page> <pre> const_cast< ConstCastTest * >( this )->number--; </pre> In const member function printNumber, the data type of the this pointer is const ConstCastTest *. The preceding statement casts away the "const- ness" of the this pointer with operator const_cast. The type of the this pointer for the remainder of that statement is now ConstCastTest *. This allows number to be modified. Operator const_cast cannot be used to directly cast away a constant variable's "const-ness". </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Operator const_cast temporarily "casts away" the const-ness of an object. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Operator const_cast cannot be used to "cast away" the const-ness of a const data member. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.5 reinterpret_cast Operator"> <page> 21.5 reinterpret_cast Operator<hr> C++ provides the reinterpret_cast operator for nonstandard casts (e.g. void * to int, etc.). Operator reinterpret_cast can also be used for standard casts (i.e., double to int, etc.). The program of <a href="^Code::c:s0p3"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.4</a> demonstrates the use of the reinterpret_cast operator. <spacer width=16 height=1>The <a href="^Portable::c:s0p0"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>program declares an integer and three pointers. Pointer voidPtr is initialized to the address of unsigned x and pointer charPtr is initialized to the C-style string "C++". Line 12 </page> <page> <pre> unsignedPtr = reinterpret_cast< unsigned * > ( voidPtr ); </pre> uses <a href="^Debug::c:s0p0"><img src="bckgrnds/icons/dbt_ico.gif" align=sidebar></a>operator reinterpret_cast to cast voidPtr (of type void *) to unsigned * pointer unsignedPtr. <spacer width=16 height=1>Lines 18 and 19 <pre> cout << "\nchar * to unsigned results in: " << ( x = reinterpret_cast< unsigned > ( charPtr ) ); </pre> output the result of casting charPtr to unsigned. The result assigned to x represents the decimal address location of the string "C++". <spacer width=16 height=1>Lines 22 and 23 </page> <page> <pre> cout << "\nunsigned to char * results in: " << reinterpret_cast< char * >( x ) << endl; </pre> cast the value of x to char *. The result is an address (char *), which results in the output of the C-style string. </page> </section> <section type=Body name=Default title="21.6 Namespaces"> <page> 21.6 Namespaces<hr> A program includes many identifiers defined in different scopes. Sometimes a variable of one scope will "overlap" with a variable of the same name in a different scope, potentially creating a problem. Such overlapping can occur at many levels. Identifier overlapping occurs frequently in third-party libraries that happen to use the same names for global identifiers (such as functions). When this occurs, compiler errors are usually generated. <spacer width=16 height=1>In an attempt to solve the problem, compiler vendors begin global identifiers names with underscores (_) and </page> <page> third-party vendors begin the name of global identifiers with their own special letter prefixes. This method works well if programmers do not begin <a href="^Practice::c:s0p3"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>identifiers with underscores and if different third-party vendors do not use the same prefixes. <spacer width=16 height=1>ANSI/ISO draft standard C++ attempts to solve this problem with namespaces. Each namespace defines a scope where global identifiers and global variables are placed. To use a namespace member, the member's name must be qualified with the namespace name and the binary scope resolution operator (::) as follows: <pre> namespace_name::member </pre> </page> <page> or a using statement must occur before the name is used; typically using statements are placed at the beginning of the file in which members of the namespace are used. For example, the statement <pre> using namespace namespace_name; </pre> at the beginning of a source code file specifies that members of namespace namespace_name can be used in the file without preceding each <a href="^Practice::c:s0p4"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>member with the namespace_name and the scope resolution operator (::). <spacer width=16 height=1>Not all namespaces are guaranteed to be unique. Two third-party vendors may inadvertently use the same </page> <page> namespace. <a href="^Code::c:s0p4"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 21.5</a> demonstrates the use of namespaces. <spacer width=16 height=1>Line 4 <pre> using namespace std; </pre> informs the compiler that namespace std is being used. The contents of header file <iostream> are all defined as part of namespace std. <spacer width=16 height=1>The <tt>using namespace</tt> statement specifies that members of a namespace will be used frequently throughout a program. This allows the programmer access to all the members of the namespace and to write more concise statements such as <pre> cout << "d = " << d; </pre> </page> <page> rather than <pre> std::cout << "d = " << d; </pre> Without line 4, every cout and endl in <a href="^Code::c:s0p4"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.5</a> would have to be qualified with std::. Many members of the C++ community nevertheless feel that writing std::cout will become the norm. The using namespace statement can be used for predefined namespaces (e.g., std) or programmer- defined namespaces. <spacer width=16 height=1>Lines 8 through 17 <pre> namespace Example { const double PI = 3.14159; const double E = 2.71828; </pre> </page> <page> <pre> int myInt = 8; void printValues(); namespace Inner { // nested namespace enum Years { FISCAL1 = 1990, FISCAL2, FISCAL3 }; } } </pre> use the keyword namespace to define namespace Example. The body of a namespace is delimited by braces ({}). Unlike class bodies, namespace bodies do not end in semicolons. Example's members consist of two constants (PI and E), an int (myInt), a function (printValues), and a nested namespace (Inner). Note that member myInt has the same name </page> <page> as global variable myInt. Variables that have the same name must have different scopes--otherwise syntax errors occur. A namespace can contain constants, data, classes, nested namespaces, functions, etc. Definitions of namespaces must occupy the global scope or be nested within other namespaces. <spacer width=16 height=1>Lines 19 through 21 <pre> namespace { double d = 88.22; } </pre> create an unnamed namespace containing the member d. Unnamed namespace <a href="^Engineer::c:s0p1"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>members occupy the global namespace, are directly accessible and do </page> <page> not have to be qualified with a namespace name. Global variables are also part of the global namespace and are accessible in all scopes following the declaration in the file. <spacer width=16 height=1>Line 26 outputs the value of d. Member d is directly accessible as part of the unnamed namespace. Line 29 outputs the value of global variable myInt. Lines 32 through 35 <pre> cout << "\nPI = " << Example::PI << "\nE = " << Example::E << "\nmyInt = " << Example::myInt << "\nFISCAL3 = " << Example::Inner::FISCAL3 << endl; </pre> </page> <page> output the values of PI, E, myInt, and FISCAL3. PI, E, and myInt are Example members and are therefore qualified with Example::. Member myInt must be qualified because a global variable has the same name. Otherwise, the global variable's value is output. FISCAL3 is a member of nested namespace Inner and is qualified with Example::Inner::. <spacer width=16 height=1>Function printValues is a member of Example and can directly access other members of the same namespace without using a namespace qualifier. The cout on line 44 outputs myInt, PI, E, d, and global variable myInt, and FISCAL3. Notice that PI and E are not qualified with Example, d is still </page> <page> accessible, the global version of myInt has been qualified with the unary scope resolution operator (::), and FISCAL3 has been qualified with Inner::. When accessing members of a nested namespace, the members must be qualified with the namespace name (unless you are inside the nested namespace). <spacer width=16 height=1>The using keyword can also be used to allow an individual namespace member to be used. For example, the line <pre> using Example::PI; </pre> would allow PI to be used <a href="^Engineer::c:s0p2"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>without namespace qualification. This is done typically when only one </page> <page> namespace <a href="^Errors::c:s0p2"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>member is frequently used. Namespaces can be aliased. For example the statement <pre> namespace CPPHTP2 = CPlusPlusHowToProgram2; </pre> creates the alias CPPHTP2 for CPlusPlusHowToProgram2. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> A namespace defines a scope. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The possibility of one namespace colliding with another namespace always exists."> namespaces are guaranteed to be unique. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Definitions of namespaces must occupy the global scope or be nested in other namespaces. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> One use of the using keyword is to allow an individual namespace member to be accessed. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.7 Run-Time Type Information (RTTI)"> <page> 21.7 Run-Time Type Information (RTTI)<hr> Run-time type information (RTTI) provides a means of determining an object's type at run time. Two important <a href="^Debug::c:s0p1"><img src="bckgrnds/icons/dbt_ico.gif" align=sidebar></a>RTTI operators are discussed in this section: typeid and dynamic_cast. The program of <a href="^Code::c:s0p5"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.6</a> demonstrates typeid and the program of <a href="^Code::c:s0p6"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.7</a> demonstrates dynamic_cast. <spacer width=16 height=1>Line 4 includes the <typeinfo.h> (<tt><typeinfo></tt> in ANSI/ISO draft standard C++) header file which defines typeid. The program defines a function template maximum that takes three arguments of the specified data type T and determines and returns the </page> <page> largest. The typename keyword is used in place of class keyword. In this situation, typename behaves identically to class. <spacer width=16 height=1>Line 18 <pre> const char *dataType = typeid( T ).name(); </pre> uses function name to return an implementation defined, C-style string; representing T's data type. The compile-time <a href="^Practice::c:s0p5"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>operator typeid returns a reference to a type_info object. A type_info object is a system maintained object that represents a type. Note that the string returned by name is owned by the system and should not be deleted by the programmer. </page> <page> Operator dynamic_cast is used in polymorphic programming to ensure that proper conversions take place at run time (i.e., the compiler cannot verify whether or not it is a proper conversion). Operator dynamic_cast is often used for downcasting from a base-class pointer to a derived-class pointer in polymorphic programming. The program of <a href="^Code::c:s0p6"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.7</a> demonstrates dynamic_cast. <spacer width=16 height=1>The program defines a base class Shape (line 7) that contains virtual function area, a derived class Circle (line 12) that publicly inherits Shape and a derived class Cylinder (line 24) that publicly </page> <page> inherits Circle. Both Circle and Cylinder override function area. <spacer width=16 height=1>In function main at lines 41 through 43, an object of class Circle called circle is instantiated, an object of class Cylinder called cylinder is instantiated and a pointer to a Shape called ptr is declared and initialized to zero. Lines 45 through 47 call <a href="^Engineer::c:s0p3"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>function outputShapeArea (defined at line 51) three times. Each call to outputShapeArea will display one of three results--the area of a Circle, the area of a Cylinder or an indication that the Shape is not a Circle or a Cylinder. Function outputShapeArea receives a pointer to a Shape as </page> <page> an argument--the first call receives the address of circle, the second call receives the address of cylinder and the third call receives a base-class Shape <a href="^Errors::c:s0p3"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>pointer called ptr. <spacer width=16 height=1>Line 57 <pre> cylinderPtr = dynamic_cast< const Cylinder * > ( shapePtr ); </pre> dynamically downcasts shapePtr (a const Shape *) to a const Cylinder * using the cast operator dynamic_cast As a result, cylinderPtr is assigned either the address of the cylinder object or 0 to indicate that the Shape is not a Cylinder. If the </page> <page> result of the cast is not 0, the area of the Cylinder is output. <spacer width=16 height=1>Line 64 <pre> circlePtr = dynamic_cast< const Circle * > ( shapePtr ); </pre> dynamically downcasts shapePtr to a const Circle * using the cast operator dynamic_cast. As a result, circlePtr is assigned either the address of the circle object or 0 to indicate that the Shape is not a Circle. If the result of the cast is not 0, the area of the Circle is output. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> RTTI provides a means of determining an object's type at execution time. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The dynamic_cast operation is performed at run-time."> dynamic_cast operations are evaluated at compile-time. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Operator typeid returns a reference to type_info object. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Attempting to use RTTI on void * pointers is a syntax error."> RTTI is often used on void * pointers to determine the data type of the address where they point. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.8 Operator Keywords"> <page> 21.8 Operator Keywords<hr> The ANSI/ISO C++ draft standard provides operator keywords (<a href="^Illustration::c:s0p1"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 21.8</a>) that can be used in place of several C++ operators. Operator keywords can be useful for programmers keyboards that do not support certain characters such as !, &, ^, ~, |, etc. <spacer width=16 height=1>The program of <a href="^Code::c:s0p7">Fig.<img src="bckgrnds/icons/code_ico.gif" align=sidebar> 21.9</a> demonstrates the use of the operator keywords. This program was compiled with Microsoft Visual C++ 5.0 which requires the header file <iso646.h> to use the operator keywords. Other compilers may differ, so check documentation for your compiler to determine the header file to include (the </page> <page> compiler may not require any header file to use these keywords). <spacer width=16 height=1>The program declares and initializes two integers a and b. Logical and bitwise operations are performed with a and b using the various operator keywords. The result of each operation is output. </page> <page> Drag the correct operator to the box associated with the operator: <component type="drag" width=16 height=18 label="&&" name="&&"> <component type="drag" width=8 height=18 label="&" name="&"> <component type="drag" width=8 height=18 label="~" name="~"> <component type="drag" width=16 height=18 label="^=" name="^="> <component type="drag" width=8 height=18 label="^" name="^"> <component type="drag" width=8 height=18 label="|" name="|"> <component type="drag" width=16 height=18 label="|=" name="|="> and<component type="drop" width=24 height=18 name="&&"> or_eq<component type="drop" width=24 height=18 name="|="> compl<component type="drop" width=24 height=18 name="~"> xor_eq<component type="drop" width=24 height=18 name="^="> or<component type="drop" width=24 height=18 name="|"> xor<component type="drop" width=24 height=18 name="^"> bitand<component type="drop" width=24 height=18 name="&"> <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.9 explicit Constructors"> <page> 21.9 explicit Constructors<hr> In Chapter 8, "Operator Overloading," we discussed that any constructor that is called with one argument can be used by the compiler to perform an implicit conversion in which the type received by the constructor is converted to an object of the class in which the constructor is defined. The conversion is automatic and the programmer need not use a cast operator. In some situations implicit conversions are undesirable or error-prone. For example, our Array class in Fig. 8.4 defines a constructor that takes a single int argument. The intent of this constructor is to create </page> <page> an Array object containing the number of elements specified by the int argument. However, this constructor can be misused by the compiler to perform an implicit conversion. The program of <a href="^Code::c:s0p8"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.10</a> uses a simplified version of class Array from Chapter 8 to demonstrate an improper implicit conversion. <spacer width=16 height=1>Line 60 in main <pre> Array integers1( 7 ); </pre> defines Array object integers1 and calls the single argument constructor with the int value 7 to specify the number of elements in the Array. We modified the Array constructor so it outputs a line of text indicating </page> <page> that the Array constructor was called and the number of elements that were allocated in the Array. Line 62 <pre> outputArray( integers1 ); // output Array integers1 </pre> calls function outputArray (defined at line 69) to output the contents of the Array. Function outputArray receives as its argument a const Array & to the Array, then outputs the Array using the overloaded stream insertion operator <<. Line 64 <pre> outputArray( 15 ); // convert 15 to an Array and output </pre> calls function outputArray with the int value 15 as an argument. There is no function outputArray </page> <page> that takes an int argument, so the compiler checks class Array to determine if there is a conversion constructor that can convert an int into an Array. Because class Array provides a conversion constructor, the compiler uses that constructor to create a temporary Array object containing 15 elements and passes the temporary Array object to function outputArray to output the Array. The output shows that the Array conversion constructor was called for a 15 element Array and the contents of the Array were output. <spacer width=16 height=1>C++ provides the keyword <tt>explicit</tt> to suppress implicit conversions via conversion constructors. A </page> <page> constructor that is declared explicit cannot be used in an implicit conversion. The program of <a href="^Code::c:s0p9"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.11</a> demonstrates an explicit constructor. <spacer width=16 height=1>The only modification to the program of <a href="^Code::c:s0p8"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.10</a> was the addition of the keyword explicit to the declaration of the single-argument constructor at line 11. When the program is compiled, the compiler produces an error message indicating that the integer value passed to outputArray at line 64 cannot be converted to a const Array &. The compiler error message is shown in the output window. Line 66 illustrates <a href="^Errors::c:s0p4"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>how to create an Array of <a href="^Errors::c:s0p5"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>15 elements and </page> <page> pass it to outputArray using <a href="^Engineer::c:s0p4"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>the explicit constructor. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Single argument constructors can be used by the compiler to perform implicit conversions. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Constructors declared can only be used to initialize objects of their class type."> An explicit single argument constructor can be used by the compiler to perform implicit conversions.explicit <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.10 mutable Class Members"> <page> 21.10 mutable Class Members<hr> In<a href="#s4p0"> Section 21.4</a>, we introduced the const_cast operator which allowed "const-ness" to be cast away. C++ provides the storage class specifier mutable as an alternative to const_cast. A mutable data member is always modifiable even in a const member function or const object. This reduces the <a href="^Portable::c:s0p1"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>need to cast away "const-ness." <spacer width=16 height=1>Both mutable and const_cast allow a data member to be modified; each is used in different contexts. For a const object with no mutable data members, operator const_cast must be used every </page> <page> time a member is to be modified. This greatly reduces the chance of a member being accidently modified because the member is not permanently modifiable. Operations involving const_cast are typically hidden in a member function's implementation. The user of a class may not be aware that a <a href="^Engineer::c:s0p5"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>member is being modified. <spacer width=16 height=1>The program of <a href="^Code::c:s0p10"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.12</a> demonstrates using a mutable member. <spacer width=16 height=1>The program defines class TestMutable (line 5) that contains a constructor, two functions and private mutable data member value. Line 8 <pre> void modifyValue() const { value++; } </pre> </page> <page> defines function modifyValue as a const function that increments mutable data member value. Normally, a const member function cannot modify data members unless the object on which the function operates--i.e., to one to which this points--is cast (using const_cast) to a non-const type. Because value is mutable, this const function is able to modify the data. Function getValue (line 9) is a const function that returns value. Note getValue could change value because value is mutable. <spacer width=16 height=1>Line 16 declares const TestMutable object t and initializes it to 99. Line 18 outputs the contents of value. Line 20 calls the const member function </page> <page> modifyValue to add one to value. Note that both t and modifyValue are const. Line 21 outputs the contents of value (100) to prove that the mutable data member was indeed modified. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> A mutable data member is always modifiable regardless of the member function or object being const. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> mutable is a storage class specifier. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.11 Pointers to Class Members (.* and ->*)"> <page> 21.11 Pointers to Class Members (.* and ->*)<hr> C++ provides the.* and ->* operators for accessing class members. Pointers to class members are not the same kind of pointers we have discussed to this point. Attempting to use the -> or * operator with a pointer to member generates syntax errors. The program of <a href="^Code::c:s0p10"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.12</a> demonstrates the pointer-to-class <a href="^Errors::c:s0p6"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>member operators. <spacer width=16 height=1>The program declares class Test which provides public member function function and public data member value. Function function outputs "function". Lines 11 and 12 prototype functions </page> <page> arrowStar and dotStar. In lines 16 through 18, object t is instantiated and data member value of t is set to 8. Lines 19 and 20 calls functions arrowStar and dotStar; each call passes the address of t. <spacer width=16 height=1>Line 26 <pre> void ( Test::*memPtr )() = &Test::function; </pre> in function arrowStar declares and initializes memPtr as a pointer to a member of class Test that is a function with a void result and no parameters. Examining the left side of the assignment--first, void is the member function's return type. The empty parenthesis indicate that this member function takes no arguments. The middle parenthesis specify a pointer </page> <page> memPtr which points to a member of class Test. The parenthesis around Test::*memPtr are required. Note that memPtr is a standard function pointer if Test:: is not specified. Next we examine <a href="^Errors::c:s0p7"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>the right value of the <a href="^Errors::c:s0p8"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>assignment. <spacer width=16 height=1>The right side of the assignment uses the address operator (&) to get the offset into the class for member function function (which must return void and take no arguments). Pointer memPtr is initialized to this offset. Note that both the left side and right side of the assignment in line 26 do not refer to any specific object. Only the class name is used with the binary scope resolution operator (::). Without the &Test::, </page> <page> the right side of the assignment in line 26 is a standard function pointer. <spacer width=16 height=1>Line 27 <pre> ( tPtr->*memPtr )(); </pre> invokes the member function to which memPtr points (function). The ->* operator is used to invoke the member function at the offset specified by memPtr. Line 32 <pre> int Test::*vPtr = &Test::value; </pre> declares and initializes vPtr as a pointer to an int data member of class Test. The right side of the assignment specifies the offset of where to find the data </page> <page> member value. Note that without the Test::, vPtr becomes an int * pointer to the address of int value. <spacer width=16 height=1>The next line <pre> cout << ( *tPtr ).*vPtr << endl; </pre> uses the.* operator to access the member to which vPtr points. <a href="^Errors::c:s0p9"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>Note that in client code we can only use pointer-to-member operators for accessible members. In this example, both value and function are public. In a member <a href="^Errors::c:s0p10"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>function of the class, all members of the class are accessible. </page> </section> <section type=Body name=Default title="21.12 Multiple Inheritance and virtual Base Classes"> <page> 21.12 Multiple Inheritance and virtual Base Classes<hr> In Chapter 9, we discussed multiple inheritance; the process by which one class inherits from two or more classes. Multiple inheritance is used, for example, in the C++ standard library to form class iostream (<a href="^Illustration::c:s0p2"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 21.14</a>). <spacer width=16 height=1>Class ios is the base class for both ostream and istream, each of which is formed with single inheritance. Class iostream inherits from both ostream and istream. This enables objects of class iostream to provide the functionality of both </page> <page> istreams and ostreams. In multiple inheritance hierarchies, the situation described in <a href="^Illustration::c:s0p2"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 21.14</a> is referred to as diamond inheritance. <spacer width=16 height=1>Because classes ostream and istream each inherit from ios, a potential problem exists for iostream. Class iostream could contain duplicate subobjects (i.e., the data from ios inherited into both ostream and istream). A problem could arise when an iostream pointer is upcast to an ios pointer. Two ios subobjects could exist. Which would then be used? Such a situation would be ambiguous and would result in a syntax error. The program of <a href="^Code::c:s0p12"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.15</a> demonstrates this kind of ambiguity but through </page> <page> implicit conversion rather than upcasting, of course, iostream does not really suffer from the problem we mentioned. In this section, we will explain how using virtual base classes solves the problem<a href="^Perform::c:s0p0"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a> of duplicate subobjects. <spacer width=16 height=1>The program defines class Base which contains pure virtual function print. Classes DerivedOne and DerivedTwo publicly inherit from Base and override print. Class DerivedOne and class DerivedTwo each contain a Base "subobject". <spacer width=16 height=1>Class Multiple multiply inherits from DerivedOne and DerivedTwo. Function print is </page> <page> overridden to call DerivedTwo's print. Note the qualification to specify which subobject version to call. <spacer width=16 height=1>In main, an object of each class in the hierarchy is created. An array of Base * pointers is also declared. Each array element is initialized to the address of an object. An error occurs when the address of both (of multiply inherited type Multiple) is implicitly converted to Base *. Object both contains duplicate subobjects inherited from Base and this of course, makes calls to function print ambiguous. A for loop is written to polymorphically call print for each of the objects pointed to by array. </page> <page> The problem of duplicate subobjects is resolved with virtual inheritance. When a base class is inherited as virtual, only one subobject will appear in the derived class--a process called <tt>virtual</tt> base class inheritance. The program of <a href="^Code::c:s0p13"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.16</a> revises the program of <a href="^Code::c:s0p12"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 21.15</a> to use a virtual base class. <spacer width=16 height=1>Class Base is defined and contains pure virtual function print. Class DerivedOne inherits from Base with the line <pre> class DerivedOne : virtual public Base { </pre> and class DerivedTwo inherits from Base with the line <pre> class DerivedTwo : virtual public Base { </pre> </page> <page> Both classes inherit from Base--each contains one subobject from Base. Class Multiple inherits from both DerivedOne and DerivedTwo. Only one subobject of Base is inherited into class Multiple. The compiler now allows conversion to occur (Multiple * to Base *). In main, an object is created for each class in the hierarchy. An array of Base pointers is also declared. Each array element is initialized to the address of an object. Note that the upcast from both's address to Base * is now permitted. A for loop is written to walk along array and polymorphically call print for each object. </page> <page> The design of hierarchies involving virtual base classes is straightforward when the default constructors are used for base classes. The previous two examples use compiler-generated default constructors. If a virtual base class provides a constructor, the design becomes more complicated because the most derived class is responsible for initializing the virtual base class. <spacer width=16 height=1>In our two examples, Base, DerivedOne, DerivedTwo, and Multiple are each the most derived class. If creating a Base object, Base is the most derived class. If creating a DerivedOne (or DerivedTwo) object, DerivedOne (or </page> <page> DerivedTwo) is the most derived class. If creating a Multiple object, Multiple is the most derived class. No matter how far down the hierarchy a class is, it is therefore the most derived class and responsible for initializing the virtual base class. In<a href="^Exercises::c:s0p18"> <img src="bckgrnds/icons/exercise.gif" align=sidebar>Exercise 21.17</a> we ask the reader to exercise <a href="^Engineer::c:s0p6"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>the concept of most derived class. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Inheritance hierarchies are capable of working when diamond inheritance occurs. Sometimes portions of the hierarchy must be redone. "> When diamond inheritance occurs, the whole inheritance hierarchy must be redesigned. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> virtual base class inheritance can solve the problem of duplicate subobjects that occur with diamond inheritance. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The most derived class is responsible for initializing the virtual base class. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="21.13 Closing Remarks "> <page> 21.13 Closing Remarks <hr> We sincerely hope you have enjoyed learning C++ and object-oriented programming in this course. The future seems clear. We wish you success in pursuing it! <spacer width=16 height=1>We would greatly appreciate your comments, criticisms, corrections, and suggestions for improving the text. We will acknowledge all contributions in the next edition of the book. Please address all correspondence to our email address: <pre> deitel@deitel.com </pre> Good luck! </page> </section> <section type=Body name=Default title="21.14 Summary"> <page> 21.14 Summary<hr> <indent width=8 delay>* The ANSI/ISO C++ draft standard provides data type <tt>bool</tt> (with values of <tt>false</tt> or <tt>true</tt>) as a preferred alternative to the old style of using 0 to indicate false and nonzero to indicate true. </indent> <indent width=8 delay>* The stream manipulator <tt>boolalpha</tt> sets the output stream to display bool values as the strings "true" and "false." </indent> <indent width=8 delay>* The ANSI/ISO C++ draft standard introduces four new cast operators to use in preference to "old-style" casting used in C and C++. </indent> <indent width=8 delay>* C++ provides the <tt>static_cast</tt> operator for con</indent> </page> <page> <indent width=8 delay>* version between types. Type checking is performed at compile time. </indent> <indent width=8 delay>* The <tt>const_cast</tt> operator casts away the const- ness of objects.</indent> <indent width=8 delay>* The reinterpret_cast operator is provided for nonstandard casts (e.g. void * to int, etc.) between unrelated types.</indent> <indent width=8 delay>* Each namespace defines a scope where global identifiers and global variables are placed. To use a namespace member, the member's name must be qualified with the namespace name and the binary scope resolution operator (::) or a using statement must occur before the name is used.</indent> </page> <page> <indent width=8 delay>* A namespace can contain constants, data, classes, nested namespaces, functions, etc. Definitions of namespaces must occupy the global scope or be nested within other namespaces.</indent> <indent width=8 delay>* Unnamed namespace members occupy the global <tt>namespace</tt>. </indent> <indent width=8 delay>* Run-time type information (RTTI) provides a means of determining an object's type at run time. </indent> <indent width=8 delay>* The compile-time operator typeid returns a reference to a type_info object. A type_info object is a system maintained object that represents a type. </indent> <indent width=8 delay>* The <tt><typeinfo.h></tt> (<tt><typeinfo></tt> in ANSI/ISO draft standard C++) header file which defines typeid. </indent> </page> <page> <indent width=8 delay>* Operator dynamic_cast is used in polymorphic programming to ensure that proper conversions take place at run time. The result of a dynamic_cast is 0 if the for invalid cast operations.</indent> <indent width=8 delay>* The ANSI/ISO C++ draft standard provides operator keywords (<a href="^Illustration::c:s0p1"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 21.8</a>) that can be used in place of several C++ operators. </indent> <indent width=8 delay>* C++ provides the keyword <tt>explicit</tt> to suppress implicit conversions via conversion constructors. A constructor that is declared explicit cannot be used in an implicit conversion. </indent> <indent width=8 delay>* A mutable data member is always modifiable even in a const member function or const object. </indent> </page> <page> <indent width=8 delay>* C++ provides the.* and ->* operators for accessing class members via pointers to those members. </indent> <indent width=8 delay>* Multiple inheritance can lead to the problem of duplicate subobjects. This is resolved with virtual inheritance. When a base class is inherited as virtual, only one subobject will appear in the derived class--a process called virtual base class inheritance. </indent> </page> </section> <section type=Popup name=Debug title="Testing"> <page> It is easy to use reinterpret_cas t to perform dangerous manipulations that could lead to serious execution-time errors. </page> <page> In order to use RTTI, some compilers require RTTI capabilities to be enabled. Check your compiler's documentation for RTTI use. </page> </section> <section type=Popup name=Terminology title="Terminology"> <page> Symbols ->* (pointer to member via object operator) <a href="$currentLink"><img src=iicons/bullbib.gif></a> .* operator <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> A and <a href="$currentLink"><img src=iicons/bullbib.gif></a> and_eq <a href="$currentLink"><img src=iicons/bullbib.gif></a> B bitand <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> bool <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> boolalpha <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> C compl <a href="$currentLink"><img src=iicons/bullbib.gif></a> </page> <page> const_cast <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> D diamond inheritance <a href="$currentLink"><img src=iicons/bullbib.gif></a> downcast <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> dynamic_cast <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> E explicit <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> F false <a href="$currentLink"><img src=iicons/bullbib.gif></a> G global namespace <a href="$currentLink"><img src=iicons/bullbib.gif></a> global variable <a href="$currentLink"><img src=iicons/bullbib.gif></a> </page> <page> I implicit conversion <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> M most derived class <a href="$currentLink"><img src=iicons/bullbib.gif></a> mutable <a href="$currentLink"><img src=iicons/bullbib.gif></a> N namespace <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> nested namespace <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> not <a href="$currentLink"><img src=iicons/bullbib.gif></a> not_eq <a href="$currentLink"><img src=iicons/bullbib.gif></a> O </page> <page> operator keywords <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> or <a href="$currentLink"><img src=iicons/bullbib.gif></a> or_eq <a href="$currentLink"><img src=iicons/bullbib.gif></a> P pointer-to-class-member operator <a href="$currentLink"><img src=iicons/bullbib.gif></a> R reinterpret_cast <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> run-time type information (RTTI) <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> S </page> <page> static_cast operator <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> subobject <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> T true <a href="$currentLink"><img src=iicons/bullbib.gif></a> typeid <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <typeinfo> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <typeinfo.h> <a href="$currentLink"><img src=iicons/bullbib.gif></a> U using statement <a href="$currentLink"><img src=iicons/bullbib.gif></a> V virtual base class <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> <a href="$currentLink"><img src=iicons/bullbib.gif></a> X </page> <page> xor <a href="$currentLink"><img src=iicons/bullbib.gif></a> xor_eq <a href="$currentLink"><img src=iicons/bullbib.gif></a> </page> </section> <section type=Popup name=Portable title="Portability"> <page> Using reinterpret_cas t can cause programs to behave differently on different platforms. </page> <page> The effect of attempting to modify an object that was defined as constant, regardless of whether that modification was made possible by a const_cast or C- style cast, varies among compilers. </page> </section> <section type=Popup name=Illustration title="Illustrations"> <page> <a href="^Code::c:s0p0">Fig. 21.1</a> Demonstrating the fundamental data type bool. <a href="^Code::c:s0p1">Fig. 21.2</a> Demonstrating operator static_cast. <a href="^Code::c:s0p2">Fig. 21.3</a> Demonstrating the const_cast operator. <a href="^Code::c:s0p3">Fig. 21.4</a> Demonstrating operator reinterpret_cast. <a href="^Code::c:s0p4">Fig. 21.5</a> Demonstrating the use of namespaces. <a href="^Code::c:s0p5">Fig. 21.6</a> Demonstrating typeid. <a href="^Code::c:s0p6">Fig. 21.7</a> Demonstrating dynamic_cast. <a href="^Illustration::c:s0p1">Fig. 21.8</a> Operator keywords as alternatives to operator symbols. <a href="^Code::c:s0p7">Fig. 21.9</a> Demonstrating the use of the operator keywords. <a href="^Code::c:s0p8">Fig. 21.10</a> Single-argument constructors and implicit conversions. <a href="^Code::c:s0p9">Fig. 21.11</a> Demonstrating an explicit constructor. <a href="^Code::c:s0p10">Fig. 21.12</a> Demonstrating a mutable data member. <a href="^Code::c:s0p11">Fig. 21.13</a> Demonstrating the.* and ->* operators. <a href="^Illustration::c:s0p2">Fig. 21.14</a> Multiple inheritance to form class iostream. <a href="^Code::c:s0p12">Fig. 21.15</a> Attempting to call a multiply inherited function polymorphically. <a href="^Code::c:s0p13">Fig. 21.16</a> Using virtual base classes. </page> <page> <a href="~audio/Ch21/21fig008.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 21.8 - Operator keywords as alternatives to operator symbols. <img src="graphics/ch21/fig21008.gif" > </page> <page> Fig<a href="~audio/Ch21/21fig014.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>ure 21.14 - Multiple inheritance to form class iostream.<img src="graphics/ch21/fig21014.gif" > </page> </section> <section type=Popup name=Perform title="Performance"> <page> Duplicate subobjects consume memory. </page> </section> <section type=Popup name=Exercises title="Exercises"> <page pagename="Exercise 21.1"> Exercise 21.1 Fill in the blanks for each of the following. a) The ________ operator qualifies a member with its namespace. b) The ________ operator allows an object's "const-ness" to be cast away. c) The ________ operator allows conversions between types. <foreign name="answers" url="^Answers::c:s0p0"> </page> <page pagename="Exercise 21.2"> Exercise 21.2 State which of the following are true and which are false. If a statement is false, explain why. a) Namespaces are guaranteed to be unique. b) Namespaces cannot have namespaces as members. c) Data type bool is a fundamental data type. <foreign name="answers" url="^Answers::c:s0p1"> </page> <page pagename="Exercise 21.3"> Exercise 21.3 Fill in the blanks for each of the following. a) The ________ operator is used to determine an object's type at run-time. b) The ________ keyword specifies that a namespace or namespace member is being used. c) The operator ________ is the operator keyword for logical OR. d) Storage specifier ________ allows a member of a const object to be modified. <foreign name="answers" url="^Answers::c:s0p2"> </page> <page pagename="Exercise 21.4"> Exercise 21.4 State which of the following are true and which are false. If a statement is false, explain why. a) The validity of a static_cast operation is checked at compile-time. b) The validity of a dynamic_cast operation is checked at run-time. c) The name typeid is a keyword. d) The explicit keyword may be applied to constructors, member functions, and data members. <foreign name="answers" url="^Answers::c:s0p3"> </page> <page pagename="Exercise 21.5"> Exercise 21.5 What does each expression evaluate to? (Note: some expressions may generate errors; if so, say what the cause of the error is.) a) cout << false; b) cout << ( bool b = 8 ); c) cout << ( a = true ); // a is of type int d) cout << ( *ptr + true && p ); // *ptr is 10 and p is 8.88 e) // *ptr is 0 and m is false <spacer width=20 height=1>bool k = ( *ptr * 2 || ( true + 24 ) ); f) bool s = true + false; g) cout << boolalpha << false << setw( 3 ) << true; </page> <page pagename="Exercise 21.6"> Exercise 21.6 Write a namespace Currency which defines constant members ONE, TWO, FIVE, TEN, TWENTY, FIFTY, and HUNDRED. Write two short programs that use Currency. One program should make all constants available and the other program should only make FIVE available. </page> <page pagename="Exercise 21.7"> Exercise 21.7 Write a program that uses the reinterpret_cast operator to cast different pointer types to int. Do any conversions result in syntax errors? <foreign name="answers" url="^Answers::c:s0p5"> </page> <page pagename="Exercise 21.8"> Exercise 21.8 Write a program that uses the static_cast operator to cast some fundamental data types to int. Does the compiler allow the casts to int? <foreign name="answers" url="^Answers::c:s0p6"> </page> <page pagename="Exercise 21.9"> Exercise 21.9 Write a program that demonstrates upcasting from a derived class to a base class. Use the static_cast operator to perform the upcast. </page> <page pagename="Exercise 21.10"> Exercise 21.10 Write a program that creates an explicit constructor that takes two arguments. Does the compiler permit this? Remove explicit and attempt an implicit conversion. Does the compiler permit this? </page> <page pagename="Exercise 21.11"> Exercise 21.11 What is the benefit of an explicit constructor? </page> <page pagename="Exercise 21.12"> Exercise 21.12 Write a program that creates a class containing two constructors. One constructor should take a single int argument. The second constructor should take one char * argument. Write a driver program that constructs several different objects; each object having a different type passed into the constructor. Do not use explicit. What happens? Now use explicit only for the constructor that takes one int. What happens? </page> <page pagename="Exercise 21.13"> Exercise 21.13 Given the following namespaces, answer whether or not each statement is true or false. Explain any false answers. <pre> 1 #include <string> 2 namespace Misc { 3 using namespace std; 4 enum Countries { POLAND, SWITZERLAND, GERMANY, 5 AUSTRIA, CZECH_REPUBLIC }; 6 int kilometers; 7 string s; 8 9 namespace Temp { 10 short y = 77; </pre> <foreign name="answers" url="^Answers::c:s0p4"> </page> <page pagename="Exercise 21.13"> <pre> 11 Car car; // assume definition exists </pre> <pre> 12 } 13 } 14 15 namespace ABC { 16 using namespace Misc::Temp; 17 void *function( void *, int ); 18 } </pre> a) Variable y is accessible within namespace ABC. b) Object s is accessible within namespace Temp. c) Constant POLAND is not accessible within namespace Temp. <foreign name="answers" url="^Answers::c:s0p4"> </page> <page pagename="Exercise 21.13"> d) Constant GERMANY is accessible within namespace ABC. e) Function function is accessible to namespace Temp. f) Namespace ABC is accessible to Misc. g) Object car is accessible to Misc. <foreign name="answers" url="^Answers::c:s0p4"> </page> <page pagename="Exercise 21.14"> Exercise 21.14 Compare and contrast mutable and const_cast. Give at least one example of when one might be preferred over the other. Note: this exercise does not require any code to be written. </page> <page pagename="Exercise 21.15"> Exercise 21.15 Write a program that uses const_cast to modify a const variable. (Hint: use a pointer in your solution to point to the const identifier. <foreign name="answers" url="^Answers::c:s0p7"> </page> <page pagename="Exercise 21.16"> Exercise 21.16 What problem does virtual base classes solve? </page> <page pagename="Exercise 21.17"> Exercise 21.17 Write a program that use virtual base classes. The class at the top of the hierarchy should provide constructor that takes at least one argument (i.e., do not provide a default constructor). What challenges does this present for the inheritance hierarchy. </page> <page pagename="Exercise 21.18"> Exercise 21.18 Find the error(s) in each of the following. When possible, explain how to correct each error. a) namespace Name { int x, y; mutable int z; }; b) int integer = const_cast< int >( float ); c) namespace PCM( 111, "hello" );// construct namespace d) explicit int x = 99; </page> </section> <section type=Popup name=Objective title="Objectives"> <page> <indent width=8 delay>* To understand and use data type bool.</indent> <indent width=8 delay>* To be able to use cast operators: static_cast, const_cast, and reinterpret_cast.</indent> <indent width=8 delay>* To understand the concept of namespaces.</indent> <indent width=8 delay>* To understand and use run-time type information (RTTI) and operators typeid and dynamic_cast.</indent> <foreign name="audio" url="~audio/Ch21/21obj.au"> </page> <page> <indent width=8 delay>* To understand operator keywords.</indent> <indent width=8 delay>* To understand explicit constructors.</indent> <indent width=8 delay>* To use mutable members in const objects.</indent> <indent width=8 delay>* To understand and use class member pointer operators .* and ->*.</indent> <indent width=8 delay>* To understand the role of virtual base classes in multiple inheritance.</indent> </page> <page> </page> </section> <section type=Popup name=Code title="Code Examples"> <page> Figure 21.1 - Demonstrating the fundamental data type bool <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_01.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_01.jar"> <foreign name="audio" url="~audio/Ch21/21fig001.au"> <foreign name="execute" url="!jarexe Run/fig21_01.jar"> </page> <page> Figure 21.2 - Demonstrating operator static_cast <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_02.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_02.jar"> <foreign name="audio" url="~audio/Ch21/21fig002.au"> <foreign name="execute" url="!jarexe Run/fig21_02.jar"> </page> <page> Figure 21.3 - Demonstrating the const_cast operator <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_03.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_03.jar"> <foreign name="audio" url="~audio/Ch21/21fig003.au"> <foreign name="execute" url="!jarexe Run/fig21_03.jar"> </page> <page> Figure 21.4 - Demonstrating operator reinterpret_cast <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_04.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_04.jar"> <foreign name="audio" url="~audio/Ch21/21fig004.au"> <foreign name="execute" url="!jarexe Run/fig21_04.jar"> </page> <page> Figure 21.5 - Demonstrating the use of namespaces <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_05.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_05.jar"> <foreign name="audio" url="~audio/Ch21/21fig005.au"> <foreign name="execute" url="!jarexe Run/fig21_05.jar"> </page> <page> Figure 21.6 - Demonstrating typeid <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_06.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_06.jar"> <foreign name="audio" url="~audio/Ch21/21fig006.au"> <foreign name="execute" url="!jarexe Run/fig21_06.jar"> </page> <page> Figure 21.7 - Demonstrating dynamic_cast <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_07.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_07.jar"> <foreign name="audio" url="~audio/Ch21/21fig007.au"> <foreign name="execute" url="!jarexe Run/fig21_07.jar"> </page> <page> Figure 21.9 - Demonstrating the use of the operator keywords <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_09.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_09.jar"> <foreign name="audio" url="~audio/Ch21/21fig009.au"> <foreign name="execute" url="!jarexe Run/fig21_09.jar"> </page> <page> Figure 21.10 - Single-argument constructors and implicit conversions <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_10.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_10.jar"> <foreign name="audio" url="~audio/Ch21/21fig010.au"> <foreign name="execute" url="!jarexe Run/fig21_10.jar"> </page> <page> Figure 21.11 - Demonstrating an explicit constructor <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_11.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_11.jar"> <foreign name="audio" url="~audio/Ch21/21fig011.au"> </page> <page> Figure 21.12 - Demonstrating a mutable data member <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_12.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_12.jar"> <foreign name="audio" url="~audio/Ch21/21fig012.au"> <foreign name="execute" url="!jarexe Run/fig21_12.jar"> </page> <page> Figure 21.13 - Demonstrating the .* and ->* operators <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_13.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_13.jar"> <foreign name="audio" url="~audio/Ch21/21fig013.au"> <foreign name="execute" url="!jarexe Run/fig21_13.jar"> </page> <page> Figure 21.15 - Attempting to call a multiply inherited function polymorphically <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_15.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_15.jar"> <foreign name="audio" url="~audio/Ch21/21fig015.au"> </page> <page> Figure 21.16 - Using virtual base classes <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch21/fig21_16.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig21_16.jar"> <foreign name="audio" url="~audio/Ch21/21fig016.au"> <foreign name="execute" url="!jarexe Run/fig21_16.jar"> </page> </section> <section type=Popup name=Practice title="Good Practices"> <page> Using true and false instead of zero and nonzero values makes programs clearer. </page> <page> When creating state variables to indicate truth or falsity, use bools in preference to ints. </page> <page> Use the safer and more reliable static_cast operator in preference to the C-style cast operator. </page> <page> Avoid beginning identifiers with the underscore character, which can lead to linker errors. </page> <page> Precede a member with its namespace name and the scope resolution operator (::) if the possibility exists of a scoping conflict. </page> <page> Using typeid in switch-like tests is a misuse of RTTI. Use virtual functions instead. </page> </section> <section type=Popup name=Errors title="Common Errors"> <page> Performing an illegal cast with operator static_cast is a syntax error. Illegal casts include casting from const types to non-const types, casting pointers and references between types that are not </page> <page> related by public inheritance, and casting to a type for which there is not an appropriate constructor or conversion operator to perform the cast. </page> <page> Placing main in a namespace is a syntax error. </page> <page> Attempting to use RTTI on a pointer of type void * is a syntax error. </page> <page> Attempting to invoke an explicit constructor for an implicit conversion is a syntax error. </page> <page> Using the explicit keyword on data members or member functions other than a single argument constructor is a syntax error. </page> <page> Attempting to use the - > or * operator with a pointer to class member is a syntax error. </page> <page> Declaring a member function pointer without enclosing the pointer name in parentheses is a syntax error. </page> <page> Declaring a member function pointer without preceding the pointer name with a class name followed by the scope resolution operator (<tt>::</tt>) is a syntax error. </page> <page> Placing space(s) between the two characters of .* or - >* is a syntax error. </page> <page> Reversing the order of the symbols in.* or - >* is a syntax error. </page> </section> <section type=Popup name=Engineer title="Engineering"> <page> With the additions to the ANSI/ISO C++ draft standard of the new cast operators (e.g., static_cast), old C-style casts are considered obsolete. </page> <page> Each separate compilation unit has its own unique unnamed namespace, i.e., the unnamed namespace replaces the static linkage specifier. </page> <page> Ideally in large programs, every entity should be declared in a class, function, block, or namespace. This helps clarify every entity's role. </page> <page> RTTI is intended for use with polymorphic inheritance hierarchies (with virtual functions). </page> <page> Use the explicit keyword on single- argument constructors that should not be used by the compiler to perform implicit conversions. </page> <page> mutable members are useful in classes that have "secret" implementation details that do not contribute to the logical value of an object. </page> <page> Providing a default constructor for virtual base classes simplifies hierarchy design. </page> </section> <section type=Popup name=AppletPopup title="Applet Examples"> <page> This chapter does not contain any Applet Examples. </page> </section> </chapter> </html> </html>